using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("BnetNearbyPlayerMgr")]
	public class BnetNearbyPlayerMgr : MonoClass
	{
		[Attribute38("BnetNearbyPlayerMgr.NearbyPlayer")]
		public class NearbyPlayer : MonoClass
		{
			public float m_lastReceivedTime => method_2<float>("m_lastReceivedTime");

			public BnetPlayer m_bnetPlayer => method_3<BnetPlayer>("m_bnetPlayer");

			public bool m_availability => method_2<bool>("m_availability");

			public ulong m_sessionStartTime => method_2<ulong>("m_sessionStartTime");

			public NearbyPlayer(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NearbyPlayer(IntPtr address)
				: this(address, "NearbyPlayer")
			{
			}

			public bool Equals(NearbyPlayer other)
			{
				return method_11<bool>("Equals", new object[1] { other });
			}

			public BnetGameAccount GetGameAccount()
			{
				return method_14<BnetGameAccount>("GetGameAccount", Array.Empty<object>());
			}

			public bool IsFriend()
			{
				return method_11<bool>("IsFriend", Array.Empty<object>());
			}
		}

		[Attribute38("BnetNearbyPlayerMgr.UdpState")]
		public class UdpState : MonoClass
		{
			public UdpState(IntPtr address, string className)
				: base(address, className)
			{
			}

			public UdpState(IntPtr address)
				: this(address, "UdpState")
			{
			}
		}

		public static int UDP_PORT => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "BnetNearbyPlayerMgr", "UDP_PORT");

		public static float UPDATE_INTERVAL => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "BnetNearbyPlayerMgr", "UPDATE_INTERVAL");

		public static float INACTIVITY_TIMEOUT => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "BnetNearbyPlayerMgr", "INACTIVITY_TIMEOUT");

		public bool m_enabled => method_2<bool>("m_enabled");

		public bool m_listening => method_2<bool>("m_listening");

		public ulong m_myGameAccountLo => method_2<ulong>("m_myGameAccountLo");

		public string m_bnetVersion => method_4("m_bnetVersion");

		public string m_bnetEnvironment => method_4("m_bnetEnvironment");

		public string m_idString => method_4("m_idString");

		public bool m_availability => method_2<bool>("m_availability");

		public int m_port => method_2<int>("m_port");

		public float m_lastCallTime => method_2<float>("m_lastCallTime");

		public List<NearbyPlayer> m_nearbyPlayers => method_3<Class271<NearbyPlayer>>("m_nearbyPlayers")?.method_25();

		public List<BnetPlayer> m_nearbyBnetPlayers => method_3<Class271<BnetPlayer>>("m_nearbyBnetPlayers")?.method_25();

		public List<BnetPlayer> m_nearbyFriends => method_3<Class271<BnetPlayer>>("m_nearbyFriends")?.method_25();

		public List<BnetPlayer> m_nearbyStrangers => method_3<Class271<BnetPlayer>>("m_nearbyStrangers")?.method_25();

		public object m_mutex => method_3<object>("m_mutex");

		public List<NearbyPlayer> m_nearbyAdds => method_3<Class271<NearbyPlayer>>("m_nearbyAdds")?.method_25();

		public List<NearbyPlayer> m_nearbyUpdates => method_3<Class271<NearbyPlayer>>("m_nearbyUpdates")?.method_25();

		public BnetNearbyPlayerMgr(IntPtr address, string className)
			: base(address, className)
		{
		}

		public BnetNearbyPlayerMgr(IntPtr address)
			: this(address, "BnetNearbyPlayerMgr")
		{
		}

		public static BnetNearbyPlayerMgr Get()
		{
			return MonoClass.smethod_15<BnetNearbyPlayerMgr>(TritonHs.MainAssemblyPath, "", "BnetNearbyPlayerMgr", "Get", Array.Empty<object>());
		}

		public void Initialize()
		{
			method_8("Initialize");
		}

		public void Shutdown()
		{
			method_8("Shutdown");
		}

		public bool IsEnabled()
		{
			return method_11<bool>("IsEnabled", Array.Empty<object>());
		}

		public void SetEnabled(bool enabled)
		{
			method_8("SetEnabled", enabled);
		}

		public bool HasNearbyStrangers()
		{
			return method_11<bool>("HasNearbyStrangers", Array.Empty<object>());
		}

		public List<BnetPlayer> GetNearbyPlayers()
		{
			return method_14<Class271<BnetPlayer>>("GetNearbyPlayers", Array.Empty<object>())?.method_25();
		}

		public List<BnetPlayer> GetNearbyFriends()
		{
			return method_14<Class271<BnetPlayer>>("GetNearbyFriends", Array.Empty<object>())?.method_25();
		}

		public List<BnetPlayer> GetNearbyStrangers()
		{
			return method_14<Class271<BnetPlayer>>("GetNearbyStrangers", Array.Empty<object>())?.method_25();
		}

		public bool IsNearbyPlayer(BnetPlayer player)
		{
			return method_10<bool>("IsNearbyPlayer", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public bool IsNearbyFriend(BnetPlayer player)
		{
			return method_10<bool>("IsNearbyFriend", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public bool IsNearbyStranger(BnetPlayer player)
		{
			return method_10<bool>("IsNearbyStranger", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public BnetPlayer FindNearbyPlayer(BnetPlayer player)
		{
			return method_15<BnetPlayer>("FindNearbyPlayer", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public BnetPlayer FindNearbyFriend(BnetPlayer player)
		{
			return method_15<BnetPlayer>("FindNearbyFriend", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public BnetPlayer FindNearbyStranger(BnetPlayer player)
		{
			return method_15<BnetPlayer>("FindNearbyStranger", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { player });
		}

		public bool GetAvailability()
		{
			return method_11<bool>("GetAvailability", Array.Empty<object>());
		}

		public void SetAvailability(bool av)
		{
			method_8("SetAvailability", av);
		}

		public void BeginListening()
		{
			method_8("BeginListening");
		}

		public void OnUdpReceive(IAsyncResult ar)
		{
			method_8("OnUdpReceive", ar);
		}

		public void StopListening()
		{
			method_8("StopListening");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void Clear()
		{
			method_8("Clear");
		}

		public void UpdateEnabled()
		{
			method_8("UpdateEnabled");
		}

		public void FireChangeEvent(BnetNearbyPlayerChangelist changelist)
		{
			method_8("FireChangeEvent", changelist);
		}

		public void CacheMyAccountInfo()
		{
			method_8("CacheMyAccountInfo");
		}

		public void ProcessPlayerChanges()
		{
			method_8("ProcessPlayerChanges");
		}

		public void ProcessAddedPlayers(BnetNearbyPlayerChangelist changelist)
		{
			method_8("ProcessAddedPlayers", changelist);
		}

		public void ProcessUpdatedPlayers(BnetNearbyPlayerChangelist changelist)
		{
			method_8("ProcessUpdatedPlayers", changelist);
		}

		public void RemoveInactivePlayers(BnetNearbyPlayerChangelist changelist)
		{
			method_8("RemoveInactivePlayers", changelist);
		}

		public bool CheckIntervalAndBroadcast()
		{
			return method_11<bool>("CheckIntervalAndBroadcast", Array.Empty<object>());
		}

		public void Broadcast()
		{
			method_8("Broadcast");
		}

		public string CreateBroadcastString()
		{
			return method_13("CreateBroadcastString");
		}

		public void UpdateNearbyPlayer(NearbyPlayer player, bool available, ulong sessionStartTime)
		{
			method_8("UpdateNearbyPlayer", player, available, sessionStartTime);
		}

		public bool IsMyPlayerOnline()
		{
			return method_11<bool>("IsMyPlayerOnline", Array.Empty<object>());
		}

		public void OnEnabledOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnEnabledOptionChanged", option, prevValue, existed, userData);
		}

		public void OnFriendsChanged(BnetFriendChangelist friendChangelist, object userData)
		{
			method_8("OnFriendsChanged", friendChangelist, userData);
		}

		public int Cheat_RemoveCheatFriends()
		{
			return method_11<int>("Cheat_RemoveCheatFriends", Array.Empty<object>());
		}
	}
}
